C++ Programming
The gold standard language for competitive programming and DSA interviews. Master STL containers (vector, set, map), algorithms library, and templates — the tools that make C++ implementation of DSA fast and clean.
₹5,000 2 Months
Arrays · Trees · Graphs · DP · Sorting · Hashing
Data Structures
& Algorithms
Complete Course
Master the most critical skill in software engineering — from Big O notation and algorithm analysis through every major data structure (arrays, linked lists, stacks, queues, trees, heaps, graphs) to advanced techniques like dynamic programming, greedy algorithms, backtracking, tries, and segment trees. The complete DSA roadmap for technical interviews and competitive programming.
Arrays
Trees
Graphs
Dynamic Programming
Sorting
Hashing
30
Classes
30h
Duration
24
Modules
100+
Problems
10–15
Batch Size
Course Details
What You Get
Everything you need to crack technical interviews at top tech companies, master competitive programming, and build a rock-solid understanding of how software works under the hood — 24 modules, 100+ problems, and a structured path from algorithm fundamentals to advanced graph and DP techniques.
30 Classes · 30 Hours
A rigorous 30-hour programme spanning 24 modules — from Big O complexity analysis and mathematical foundations through recursion, every major data structure, all classic sorting and searching algorithms, and advanced topics including dynamic programming, backtracking, tries, segment trees, and disjoint set union.
ISO & MSME Certificate
Earn a government-recognized, ISO-certified DSA completion certificate. This credential validates your algorithmic expertise when applying for software engineer, SDE, and developer roles across India's IT industry, product companies, and multinational firms.
100+ Problem Sessions
Solve 100+ carefully chosen problems that appear frequently in technical interviews at companies like TCS, Infosys, Wipro, Amazon, and Flipkart. Problems are organized by topic — from array manipulation and string algorithms to graph traversal and DP optimization.
Small Batch Sizes
Only 10–15 students per batch ensures every student gets personal attention. Complex topics like recursive tree traversal, dynamic programming state transitions, and Dijkstra's shortest path algorithm need small groups and hands-on debugging time to truly master.
Bengali & Hindi Medium
DSA concepts — amortized analysis, memoization vs. tabulation, disjoint set union by rank, KMP failure function, Kosaraju's SCC algorithm — explained clearly in Bengali and Hindi so every student understands the intuition and the mathematics, not just the code.
Interview & Placement Prep
The entire curriculum is structured around what top companies actually test — FAANG-pattern questions on arrays, linked lists, trees, and graphs; system design foundations; complexity analysis in interviews; and the mental models that make you confident when solving problems under pressure.
Full Curriculum
Course Syllabus
24 comprehensive modules — from algorithm analysis and Big O through every major data structure, sorting algorithms, dynamic programming, graph theory, and advanced structures like Tries, Segment Trees, and Disjoint Sets.
Modules 1–4: Algorithm Analysis, Mathematics, Bit Magic & Recursion
Before writing a single data structure, every serious programmer must understand how to measure algorithmic efficiency. These four modules build the mathematical and conceptual bedrock that everything else rests on. You'll learn to analyze any algorithm's time and space complexity, predict how code will behave as input grows, leverage bit manipulation for O(1) tricks, and harness recursion to elegantly solve problems that would require pages of iterative code. This is the vocabulary of technical interviews.
4 ModulesBig O / Omega / ThetaBit ManipulationRecursion TreesSpace Complexity
01
Analysis of Algorithm & Order of GrowthBackground analysis through programs and their functions. Mathematical explanation of growth analysis through limits and functions. Direct methods for calculating order of growth. Why understanding growth rates is the single most important skill for writing scalable software — and for passing algorithmic interviews.
02
Asymptotic Notations — Big O, Omega & ThetaBest, Average, and Worst case analysis with program examples. Big O (upper bound), Omega (lower bound), and Theta (tight bound) — graphical and mathematical explanations. Analysis of common loops: single, multiple, and nested. Analysis of recursion through Recursion Tree method. Space complexity analysis including auxiliary space and recursive call stack overhead.
03
Mathematics for DSACount Digits, Palindrome Numbers, Factorial of Numbers. GCD of Two Numbers (Euclidean algorithm). LCM, Check for Prime, Prime Factors. Sieve of Eratosthenes for bulk prime generation. Computing Powers efficiently with fast exponentiation — O(log n) instead of O(n). The mathematical toolkit that shows up in competitive programming and technical interviews.
04
Bit Magic — Bitwise Operators (C++ & Java)AND, OR, XOR operators and their applications. Left Shift, Right Shift, and Bitwise NOT. Java's unsigned right shift (>>>). Bit tricks for competitive programming: checking if a number is a power of 2, counting set bits, swapping without a temp variable, finding the single non-duplicate element. These O(1) techniques appear constantly in advanced algorithm problems.
05
Recursion — Introduction, Applications & Base CasesIntroduction to recursion and why it is fundamentally different from iterative thinking. Applications of recursion across problem domains. Writing base cases correctly — the most common source of recursive bugs. Classic recursive implementations: Factorial, N-th Fibonacci number. Various problems on recursion that build intuition. The mental model shift from "how do I do this step by step" to "what is the smallest version of this problem."
Modules 5–8: Arrays, Searching, Sorting & Matrix — The Interview Core
Arrays are the most fundamental data structure and the most heavily tested in technical interviews. This block covers every array technique interviewers use — from rotation and sliding windows to two-pointer and prefix sums. Searching covers Binary Search and its variants exhaustively. Sorting covers every algorithm from Bubble Sort to Radix Sort with complexity analysis. Matrix covers traversal patterns used in dynamic programming and graph problems. Master these four modules and you'll handle 60% of all technical interview questions with confidence.
4 ModulesSliding WindowTwo PointerBinary SearchMerge SortQuick SortMatrix Traversal
01
Arrays — Introduction, Types & Core OperationsFixed-sized vs. dynamic-sized arrays. Searching, insertion, deletion — with complexity analysis. Arrays vs. other data structures. Reversing with complexity. Problems covered:
- Left Rotation by 1 and by D places
- Leaders in an Array
- Maximum Difference Problem
- Stock Buy and Sell Problem
- Trapping Rainwater Problem
- Maximum Consecutive 1s
- Maximum Subarray Sum (Kadane's Algorithm)
- Sliding Window Technique
- Prefix Sum Technique
02
Searching — Binary Search & Two PointerBinary Search iterative and recursive. Index of First/Last Occurrence in sorted array. Count of occurrences. Find an element in sorted and rotated array. Peak element problem. Square root of an integer. Two Pointer approach: pair sum in unsorted/sorted arrays, triplet sum, median of two sorted arrays, Majority Element.
03
Sorting — All Major Algorithms with Complexity AnalysisBubble Sort, Selection Sort, Insertion Sort, Merge Sort (with count inversions), Quick Sort (Lomuto & Hoare partitions, pivot choice, tail call elimination), Heap Sort, Cycle Sort, Counting Sort, Radix Sort, Bucket Sort. Problems: Kth Smallest element, Chocolate Distribution Problem, Sorting 2/3-type element arrays, Merge Overlapping Intervals, Meeting Maximum Guests.
04
Matrix — Traversal Patterns & OperationsIntroduction to 2D arrays. Multidimensional matrix operations. Pass Matrix as argument. Snake pattern printing, transposing a matrix. Element search in row-and-column-wise sorted matrix. Boundary Traversal, Spiral Traversal. Matrix Multiplication. Search in sorted matrix — these traversal patterns appear constantly in DP and graph problems.
Modules 9–14: Hashing, Strings, Linked List, Stack, Queue & Deque
These six modules cover the linear data structures that form the core of almost every technical interview round. Hashing enables O(1) average-case lookup — the key to solving subarray and frequency problems efficiently. Strings are tested in every interview with pattern matching, anagram, and palindrome problems. Linked lists test pointer manipulation skills. Stacks solve expression evaluation, bracket matching, and monotonic problems. Queues and Deques appear in BFS, sliding window maximum, and system design. Together these modules cover an enormous breadth of interview territory.
6 ModulesHash Maps/SetsKMP AlgorithmFloyd CycleLRU CacheMonotonic StackDeque
01
Hashing — Architecture, Collision Handling & ProblemsDirect Address Table, Hash Functions, Collision Handling (Chaining, Open Addressing, Double Hashing). C++ Unordered Set/Map; Java HashSet/HashMap. Problems: Count Distinct Elements, Frequency Count, Intersection & Union of arrays, Pair/Subarray with given sum, Longest subarray with 0 sum, Longest subarray equal 0s and 1s, Longest Consecutive Subsequence, Count Distinct elements in every window, More than n/k Occurrences.
02
Strings — Algorithms & Classic ProblemsString DS discussion. Strings in C++ and Java. Problems: Anagram check, Leftmost repeating/non-repeating character, Lexicographic rank in O(n), Permutation of pattern in text, Rotation check. Pattern Searching Algorithms. Palindrome Check. Rabin-Karp Algorithm. KMP Algorithm — one of the most famous string algorithms, essential for senior developer interviews.
03
Linked List — Singly, Doubly & CircularIntroduction, Doubly Linked List, Circular Linked List. Loop detection with Floyd's cycle detection algorithm. Problems: Middle of Linked List, Nth from end, Reverse (iterative & recursive), Reverse in groups of k, Segregate even-odd, Intersection of two lists, Pairwise swap, Clone with random pointer, LRU Cache Design, Merge two sorted lists, Palindrome check, Remove duplicates, Sorted Insert, Reverse Doubly Linked List.
04
Stack — Implementation, Applications & Classic ProblemsUnderstanding Stack, applications, implementation with Array and Linked List. Problems: Balanced Parenthesis, Two Stacks in an array, K Stacks in an array, Stock Span Problem, Previous Greater Element, Next Greater Element, Largest Rectangle in Histogram. getMin() in O(1). Infix/Prefix/Postfix conversion (simple and efficient) and evaluation — fundamental computer science concepts that appear in compiler design interviews.
05
Queue & Deque — Implementation & ProblemsQueue introduction and applications. Implementation using array and LinkedList. Problems: Reversing a Queue, Generate numbers with given digits, First Circular Tour. Deque (Double-Ended Queue): implementation and Maximums of all subarrays of size k (sliding window maximum — a classic problem). ArrayDeque in Java. Design a DS with min-max operations — a compound data structure design problem.
Modules 15–17: Binary Trees, Binary Search Trees & Heaps
Trees are the most complex and most tested data structure category in technical interviews. Binary trees test recursive thinking at its deepest — nearly every tree problem is solved by applying a recursive insight to the left and right subtrees. Binary Search Trees (BST) add ordering invariants that enable efficient search, insert, and delete. Heaps (priority queues) solve the "K largest/smallest" class of problems optimally. This three-module block also covers self-balancing BSTs (AVL, Red-Black), C++ STL Set/Map, and Java TreeSet/TreeMap — essential tools for competitive programming.
3 ModulesTree TraversalsLCABST OperationsAVL TreeRed-Black TreePriority QueueHeap Sort
01
Binary Tree — Traversals & Classic ProblemsTree introduction and applications. Inorder, Preorder, Postorder, Level Order (line by line), and Spiral traversal — both recursive and iterative implementations. Problems: Size, Maximum, Height, Nodes at K distance, Left View, Children Sum Property, Balanced Binary Tree check, Maximum Width, Convert to Doubly Linked List, Construct from Inorder+Preorder, Diameter, LCA (Lowest Common Ancestor), Burn from a Leaf, Count Nodes in Complete Binary Tree, Serialize/Deserialize.
02
Binary Search Tree — Operations & Self-Balancing TreesBST Introduction, Search, Insertion, Deletion, Floor in BST. Self-Balancing BST motivation. AVL Tree rotations. Red-Black Tree properties. C++ Set/Map and Java TreeSet/TreeMap. Problems: Ceiling on left side, Kth Smallest in BST, Check for valid BST, Fix BST with two nodes swapped, Pair Sum in BST, Vertical Sum, Vertical Traversal, Top View, Bottom View — these appear in FAANG-level interviews.
03
Heap — Binary Heap, Priority Queue & ProblemsIntroduction and implementation. Binary Heap: Insertion, Heapify, Extract-Min/Max, Decrease Key, Delete, Build Heap in O(n). Heap Sort. Priority Queue (C++ and Java). Problems: Sort K-Sorted Array, Buy Maximum Items with Given Sum, K Largest Elements, Merge K Sorted Arrays, Median of a Stream (using two heaps — a classic problem combining max-heap and min-heap for optimal performance).
Module 18: Graph Theory — BFS, DFS, Shortest Paths & Advanced Algorithms
Graphs are the most powerful and versatile data structure — they model networks, maps, social connections, dependencies, and countless real-world systems. This module starts from representation (adjacency matrix and list) and builds up through BFS and DFS traversals, shortest path algorithms (Dijkstra, Bellman-Ford), Minimum Spanning Trees (Prim's, Kruskal's), topological sorting for dependency problems, and advanced algorithms like Kosaraju's for strongly connected components, Tarjan's algorithm, articulation points, and bridges in graphs.
BFS & DFSDijkstraBellman-FordPrim's MSTKruskal'sTopological SortKosaraju'sTarjan's
01
Graph Representation — Adjacency Matrix & ListIntroduction to Graph theory. Adjacency Matrix: O(V²) space, O(1) edge lookup. Adjacency List in C++ (vector of vectors) and Java (ArrayList of ArrayLists): O(V+E) space. When to use each representation — crucial for choosing the right approach in interviews and competitive programming.
02
BFS & DFS — Traversals & ApplicationsBreadth-First Search: level-order exploration, shortest path in unweighted graphs, cycle detection. Depth-First Search: recursive and iterative, topological sorting, cycle detection in directed graphs. Applications of both. Problems: Shortest Path in Unweighted Graph, Detecting Cycle, Topological Sorting of a DAG.
03
Shortest Path AlgorithmsShortest Path in a Directed Acyclic Graph using topological sort + relaxation. Dijkstra's Algorithm: greedy approach for non-negative weighted graphs, O((V+E) log V) with priority queue. Bellman-Ford Algorithm: handles negative weights, detects negative cycles, O(VE). Understanding when each algorithm applies — critical for system design and interview discussions.
04
Minimum Spanning Trees & Advanced Graph AlgorithmsPrim's Algorithm: greedy MST construction using priority queue. Kruskal's Algorithm: MST using Disjoint Set Union + sorting edges. Kosaraju's Algorithm for Strongly Connected Components. Articulation Points (cut vertices) in a graph. Bridges in graphs (critical edges). Tarjan's Algorithm for SCC. Practice Problems to consolidate all graph concepts.
Modules 19–24: Greedy, Backtracking, Dynamic Programming, Trie, Segment Tree & DSU
The final six modules cover the advanced algorithmic techniques that define top-tier competitive programmers and senior software engineers. Greedy algorithms solve optimization problems by making locally optimal choices. Backtracking explores all possibilities systematically (N-Queens, Sudoku). Dynamic Programming transforms exponential brute-force solutions into polynomial ones through memoization and tabulation. Tries enable O(L) string search where hashmaps fail. Segment Trees answer range queries in O(log n). Disjoint Set Union (DSU) enables near-O(1) union-find for connectivity queries.
6 ModulesGreedyBacktrackingMemoizationTabulationTrieSegment TreeDSU
01
Greedy AlgorithmsIntroduction to the greedy paradigm. Activity Selection Problem (interval scheduling). Fractional Knapsack. Job Sequencing Problem with deadlines. Huffman Coding for data compression — one of the most elegant applications of greedy algorithms in real-world software. When greedy works and when it doesn't (vs. DP).
02
BacktrackingConcepts of backtracking — systematic exploration of the solution space with pruning. Rat In a Maze: finding paths in a grid with obstacles. N-Queen Problem: placing N queens on an NxN board with no conflicts — a classic backtracking benchmark. Sudoku Solver: constraint propagation with backtracking — the same technique used in professional Sudoku solvers and constraint satisfaction systems.
03
Dynamic Programming — Memoization & TabulationDP introduction: overlapping subproblems + optimal substructure. Memoization (top-down) vs. Tabulation (bottom-up). Classic DP problems:
- Longest Common Subsequence
- Coin Change (Count Combinations)
- Edit Distance Problem
- Longest Increasing Subsequence
- Maximum Cuts
- Minimum Coins to Make a Value
- Minimum Jumps to Reach End
- 0-1 Knapsack Problem
- Optimal Strategy for a Game
- Egg Dropping Problem
- Count BST with N keys
- Maximum Sum with No Consecutive
- Subset Sum Problem
- Matrix Chain Multiplication
- Palindrome Partitioning
04
Trie — Representation, Operations & ProblemsIntroduction to Trie (prefix tree) — why O(L) search beats O(L log N) BST and O(L) average hashmap for string operations. Representation, Search, Insert, Delete operations. Count Distinct Rows in a Binary Matrix. Tries are used in autocomplete systems, spell checkers, IP routing, and word game solvers — a powerful structure every senior developer should know.
05
Segment Tree — Range Queries in O(log N)Introduction to Segment Tree — the go-to structure when you need to answer range queries (sum, minimum, maximum) over a dynamic array. Construction in O(N). Range Query in O(log N). Update Query in O(log N). Segment trees are used in competitive programming, database indexing, and computational geometry. Understanding this structure puts you firmly in the top tier of competitive programmers.
06
Disjoint Set Union (DSU) — Union Find with OptimizationsIntroduction to DSU and the Union-Find problem. Find and Union operations (naive). Union by Rank — prevents degenerate O(N) trees. Path Compression — the genius optimization that makes Find nearly O(1). Combined: nearly O(α(N)) per operation (inverse Ackermann — practically constant). Kruskal's Algorithm implementation using DSU — the connection back to graph theory that shows how these structures compose.
What You'll Learn
Learning Outcomes
Graduate as a confident problem solver — capable of analyzing any algorithm's complexity, choosing the right data structure for any problem, and solving the kinds of questions that top tech companies ask in their technical interviews.
Analyze Any Algorithm's Complexity
Calculate time and space complexity of any code you read or write — confidently explain Big O, Omega, and Theta notation, analyze loops and recursion, and compare the efficiency of competing solutions. This is the foundation of all technical interview success.
Solve Array & String Problems Fluently
Apply sliding window, two-pointer, prefix sum, and binary search techniques to solve the full spectrum of array and string interview problems — from Kadane's algorithm to KMP pattern matching. These topics alone cover 50%+ of first-round interview questions.
Master Tree & Graph Algorithms
Traverse binary trees with confidence (recursive and iterative), implement BST operations, use heaps for priority-based problems, and apply BFS, DFS, Dijkstra, and Prim's algorithm to graph problems. Tree and graph questions dominate FAANG-level interviews.
Apply Dynamic Programming
Recognize DP problems by identifying overlapping subproblems and optimal substructure. Implement both memoization (top-down) and tabulation (bottom-up) approaches. Solve the classic DP problems — knapsack, LCS, edit distance, LIS, coin change — that appear in nearly every challenging technical interview.
Navigate Linked Lists & Hash Structures
Implement and manipulate linked lists — reverse, detect cycles, merge sorted lists, and clone with random pointers. Use hash maps and sets to convert O(n²) brute-force solutions into O(n) optimal ones. These two topics appear in every company's first technical screen.
Interview & Competitive Programming Readiness
Walk into any technical interview — TCS, Infosys, Wipro, campus placements, or product company interviews — with genuine confidence. The 100+ problems solved across 24 modules build the pattern recognition and problem-solving reflexes that separate candidates who get offers from those who don't.
Who Should Join?
This Course Is For You
DSA is not optional for software engineers — it's the foundational skill that every technical interview tests. Whether you're a student preparing for campus placements or a developer looking to crack FAANG, this is where you start.
🎓
CS & IT Students
BCA, MCA, B.Tech, BSc IT, and Diploma students preparing for campus placements at TCS, Infosys, Wipro, Cognizant, and other IT companies. Every major IT recruiter in India tests DSA — arrays, linked lists, trees, sorting, and dynamic programming questions are standard in every pool campus and off-campus recruitment test.
💻
Working Developers
Software developers who write code professionally but haven't formally studied algorithms. DSA knowledge is what separates developers who stay at service companies from those who move to product companies with 3–5x higher salaries. If you want to pass technical screens at Amazon, Flipkart, Swiggy, or Zomato — this course is the path.
🏆
Competitive Programmers
Students who want to compete on Codeforces, LeetCode, HackerRank, and CodeChef. The 24-module curriculum covers everything tested in competitive programming: advanced graph algorithms, dynamic programming patterns, segment trees, DSU, and Trie — the toolkit that top competitive programmers rely on.
FAQ
Frequently Asked Questions
What is the fee for the DSA course at PBA Institute?
The batch class fee is ₹3,000 for the complete course — 30 classes, 30 hours, 24 modules covering Algorithm Analysis, Big O, Recursion, Arrays, Sorting, Searching, Hashing, Strings, Linked List, Stack, Queue, Trees, BST, Heaps, Graphs, Greedy, Backtracking, Dynamic Programming, Trie, Segment Tree, and Disjoint Set. One-to-One personalized sessions are available at a higher fee with flexible scheduling. Both include study materials and an ISO-certified government-recognized certificate.
What programming language is used in the DSA course?
The course covers implementations in both C++ and Java — the two most commonly used languages for competitive programming and technical interviews. Data structure implementations (STL unordered_set, TreeMap, ArrayDeque) are shown in both languages so students can apply their knowledge regardless of the language required in their target company's interviews.
Do I need prior programming knowledge for the DSA course?
Basic programming knowledge in C++, Java, or Python is recommended — you should know how to write functions, loops, and basic conditional logic. The course builds from algorithm analysis fundamentals, so you don't need prior DSA knowledge. Students who know C or Python can follow along; just let the instructor know your background so they can bridge the language gap where needed.
Is the DSA course available online?
Yes. PBA Institute offers both online and classroom DSA classes with live instructor demonstrations, real-time problem-solving sessions, and direct doubt resolution. Online students receive the same curriculum, the same problem sets, and the same ISO-certified certificate as in-person students.
How does this DSA course help with placement interviews?
The entire curriculum is structured around what companies actually test. Arrays, linked lists, trees, and graphs with Big O analysis are standard in every company's first round. Dynamic programming appears in second and third rounds at product companies. Sorting algorithms and hashing are tested in written aptitude rounds. The 100+ problems solved across the course build the pattern recognition that makes you fast and confident when solving problems under time pressure in an actual interview.
Should I learn DSA before or after learning a programming language?
After — you need basic programming proficiency to implement data structures. The ideal path is: (1) Learn a language like C, C++, or Java first, (2) Take this DSA course to understand the structures and algorithms, (3) Combine with the language course at PBA Institute for the strongest foundation. Many students take our C++ or Java course first and then enroll in DSA — this is the most effective sequence for placement preparation.
The Most Important Skill in Software Engineering
Ready to Master Data Structures & Algorithms?
Join PBA Institute's DSA course in Howrah. Master algorithm analysis, arrays, trees, graphs, dynamic programming, and 20+ more topics across 30 classes. Solve 100+ problems. Earn an ISO certificate and crack technical interviews at India's top IT companies.
Explore More
Related Courses
Build on your DSA skills with these courses at PBA Institute — each a natural next step or powerful foundation for your algorithmic knowledge.